package com.google.zxing.pdf417.decoder;

import com.google.zxing.ChecksumException;
import com.google.zxing.FormatException;
import com.google.zxing.NotFoundException;
import com.google.zxing.ResultPoint;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.common.DecoderResult;
import com.google.zxing.pdf417.PDF417Common;
import com.google.zxing.pdf417.decoder.ec.ErrorCorrection;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Formatter;
import java.util.List;

public final class PDF417ScanningDecoder
{
  private static final int CODEWORD_SKEW_SIZE = 2;
  private static final int MAX_EC_CODEWORDS = 512;
  private static final int MAX_ERRORS = 3;
  private static final ErrorCorrection errorCorrection = new ErrorCorrection();

  private static BoundingBox adjustBoundingBox(DetectionResultRowIndicatorColumn paramDetectionResultRowIndicatorColumn)
    throws NotFoundException, FormatException
  {
    if (paramDetectionResultRowIndicatorColumn == null);
    int[] arrayOfInt;
    do
    {
      return null;
      arrayOfInt = paramDetectionResultRowIndicatorColumn.getRowHeights();
    }
    while (arrayOfInt == null);
    int i = getMax(arrayOfInt);
    int j = 0;
    int k = arrayOfInt.length;
    Codeword[] arrayOfCodeword;
    for (int m = 0; ; m++)
      if (m < k)
      {
        int i4 = arrayOfInt[m];
        j += i - i4;
        if (i4 <= 0);
      }
      else
      {
        arrayOfCodeword = paramDetectionResultRowIndicatorColumn.getCodewords();
        for (int n = 0; (j > 0) && (arrayOfCodeword[n] == null); n++)
          j--;
      }
    int i1 = 0;
    for (int i2 = -1 + arrayOfInt.length; ; i2--)
      if (i2 >= 0)
      {
        i1 += i - arrayOfInt[i2];
        if (arrayOfInt[i2] <= 0);
      }
      else
      {
        for (int i3 = -1 + arrayOfCodeword.length; (i1 > 0) && (arrayOfCodeword[i3] == null); i3--)
          i1--;
      }
    return paramDetectionResultRowIndicatorColumn.getBoundingBox().addMissingRows(j, i1, paramDetectionResultRowIndicatorColumn.isLeft());
  }

  private static void adjustCodewordCount(DetectionResult paramDetectionResult, BarcodeValue[][] paramArrayOfBarcodeValue)
    throws NotFoundException
  {
    int[] arrayOfInt = paramArrayOfBarcodeValue[0][1].getValue();
    int i = paramDetectionResult.getBarcodeColumnCount() * paramDetectionResult.getBarcodeRowCount() - getNumberOfECCodeWords(paramDetectionResult.getBarcodeECLevel());
    if (arrayOfInt.length == 0)
    {
      if ((i < 1) || (i > 928))
        throw NotFoundException.getNotFoundInstance();
      paramArrayOfBarcodeValue[0][1].setValue(i);
    }
    while (arrayOfInt[0] == i)
      return;
    paramArrayOfBarcodeValue[0][1].setValue(i);
  }

  private static int adjustCodewordStartColumn(BitMatrix paramBitMatrix, int paramInt1, int paramInt2, boolean paramBoolean, int paramInt3, int paramInt4)
  {
    int i = paramInt3;
    int j;
    int k;
    if (paramBoolean)
    {
      j = -1;
      k = 0;
      if (k >= 2);
    }
    else
    {
      while (true)
      {
        if (((!paramBoolean) || (i < paramInt1)) && ((paramBoolean) || (i >= paramInt2) || (paramBoolean != paramBitMatrix.get(i, paramInt4))))
          break label83;
        if (Math.abs(paramInt3 - i) > 2)
        {
          return paramInt3;
          j = 1;
          break;
        }
        i += j;
      }
      label83: j = -j;
      if (!paramBoolean);
      for (paramBoolean = true; ; paramBoolean = false)
      {
        k++;
        break;
      }
    }
    return i;
  }

  private static boolean checkCodewordSkew(int paramInt1, int paramInt2, int paramInt3)
  {
    return (paramInt2 - 2 <= paramInt1) && (paramInt1 <= paramInt3 + 2);
  }

  private static int correctErrors(int[] paramArrayOfInt1, int[] paramArrayOfInt2, int paramInt)
    throws ChecksumException
  {
    if (((paramArrayOfInt2 != null) && (paramArrayOfInt2.length > 3 + paramInt / 2)) || (paramInt < 0) || (paramInt > 512))
      throw ChecksumException.getChecksumInstance();
    return errorCorrection.decode(paramArrayOfInt1, paramInt, paramArrayOfInt2);
  }

  private static BarcodeValue[][] createBarcodeMatrix(DetectionResult paramDetectionResult)
    throws FormatException
  {
    BarcodeValue[][] arrayOfBarcodeValue = (BarcodeValue[][])Array.newInstance(BarcodeValue.class, new int[] { paramDetectionResult.getBarcodeRowCount(), 2 + paramDetectionResult.getBarcodeColumnCount() });
    for (int i = 0; i < arrayOfBarcodeValue.length; i++)
      for (int i3 = 0; i3 < arrayOfBarcodeValue[i].length; i3++)
        arrayOfBarcodeValue[i][i3] = new BarcodeValue();
    int j = 0;
    for (DetectionResultColumn localDetectionResultColumn : paramDetectionResult.getDetectionResultColumns())
    {
      if (localDetectionResultColumn != null)
        for (Codeword localCodeword : localDetectionResultColumn.getCodewords())
          if (localCodeword != null)
          {
            int i2 = localCodeword.getRowNumber();
            if (i2 >= 0)
            {
              if (i2 >= arrayOfBarcodeValue.length)
                throw FormatException.getFormatInstance();
              arrayOfBarcodeValue[i2][j].setValue(localCodeword.getValue());
            }
          }
      j++;
    }
    return arrayOfBarcodeValue;
  }

  private static DecoderResult createDecoderResult(DetectionResult paramDetectionResult)
    throws FormatException, ChecksumException, NotFoundException
  {
    BarcodeValue[][] arrayOfBarcodeValue = createBarcodeMatrix(paramDetectionResult);
    adjustCodewordCount(paramDetectionResult, arrayOfBarcodeValue);
    ArrayList localArrayList1 = new ArrayList();
    int[] arrayOfInt1 = new int[paramDetectionResult.getBarcodeRowCount() * paramDetectionResult.getBarcodeColumnCount()];
    ArrayList localArrayList2 = new ArrayList();
    ArrayList localArrayList3 = new ArrayList();
    for (int i = 0; i < paramDetectionResult.getBarcodeRowCount(); i++)
    {
      int k = 0;
      if (k < paramDetectionResult.getBarcodeColumnCount())
      {
        int[] arrayOfInt2 = arrayOfBarcodeValue[i][(k + 1)].getValue();
        int m = k + i * paramDetectionResult.getBarcodeColumnCount();
        if (arrayOfInt2.length == 0)
          localArrayList1.add(Integer.valueOf(m));
        while (true)
        {
          k++;
          break;
          if (arrayOfInt2.length == 1)
          {
            arrayOfInt1[m] = arrayOfInt2[0];
          }
          else
          {
            localArrayList3.add(Integer.valueOf(m));
            localArrayList2.add(arrayOfInt2);
          }
        }
      }
    }
    int[][] arrayOfInt = new int[localArrayList2.size()][];
    for (int j = 0; j < arrayOfInt.length; j++)
      arrayOfInt[j] = ((int[])localArrayList2.get(j));
    return createDecoderResultFromAmbiguousValues(paramDetectionResult.getBarcodeECLevel(), arrayOfInt1, PDF417Common.toIntArray(localArrayList1), PDF417Common.toIntArray(localArrayList3), arrayOfInt);
  }

  private static DecoderResult createDecoderResultFromAmbiguousValues(int paramInt, int[] paramArrayOfInt1, int[] paramArrayOfInt2, int[] paramArrayOfInt3, int[][] paramArrayOfInt)
    throws FormatException, ChecksumException
  {
    int[] arrayOfInt = new int[paramArrayOfInt3.length];
    int i = 100;
    int j = i - 1;
    if (i > 0)
    {
      for (int k = 0; k < arrayOfInt.length; k++)
        paramArrayOfInt1[paramArrayOfInt3[k]] = paramArrayOfInt[k][arrayOfInt[k]];
      int m;
      try
      {
        DecoderResult localDecoderResult = decodeCodewords(paramArrayOfInt1, paramInt, paramArrayOfInt2);
        return localDecoderResult;
      }
      catch (ChecksumException localChecksumException)
      {
        if (arrayOfInt.length == 0)
          throw ChecksumException.getChecksumInstance();
        m = 0;
      }
      while (true)
      {
        if (m < arrayOfInt.length)
        {
          if (arrayOfInt[m] < -1 + paramArrayOfInt[m].length)
            arrayOfInt[m] = (1 + arrayOfInt[m]);
        }
        else
        {
          i = j;
          break;
        }
        arrayOfInt[m] = 0;
        if (m == -1 + arrayOfInt.length)
          throw ChecksumException.getChecksumInstance();
        m++;
      }
    }
    throw ChecksumException.getChecksumInstance();
  }

  public static DecoderResult decode(BitMatrix paramBitMatrix, ResultPoint paramResultPoint1, ResultPoint paramResultPoint2, ResultPoint paramResultPoint3, ResultPoint paramResultPoint4, int paramInt1, int paramInt2)
    throws NotFoundException, FormatException, ChecksumException
  {
    BoundingBox localBoundingBox = new BoundingBox(paramBitMatrix, paramResultPoint1, paramResultPoint2, paramResultPoint3, paramResultPoint4);
    DetectionResultRowIndicatorColumn localDetectionResultRowIndicatorColumn1 = null;
    DetectionResultRowIndicatorColumn localDetectionResultRowIndicatorColumn2 = null;
    DetectionResult localDetectionResult = null;
    int i = 0;
    while (i < 2)
    {
      if (paramResultPoint1 != null)
        localDetectionResultRowIndicatorColumn1 = getRowIndicatorColumn(paramBitMatrix, localBoundingBox, paramResultPoint1, true, paramInt1, paramInt2);
      if (paramResultPoint3 != null)
        localDetectionResultRowIndicatorColumn2 = getRowIndicatorColumn(paramBitMatrix, localBoundingBox, paramResultPoint3, false, paramInt1, paramInt2);
      localDetectionResult = merge(localDetectionResultRowIndicatorColumn1, localDetectionResultRowIndicatorColumn2);
      if (localDetectionResult == null)
        throw NotFoundException.getNotFoundInstance();
      if ((i == 0) && (localDetectionResult.getBoundingBox() != null) && ((localDetectionResult.getBoundingBox().getMinY() < localBoundingBox.getMinY()) || (localDetectionResult.getBoundingBox().getMaxY() > localBoundingBox.getMaxY())))
      {
        localBoundingBox = localDetectionResult.getBoundingBox();
        i++;
      }
      else
      {
        localDetectionResult.setBoundingBox(localBoundingBox);
      }
    }
    int j = 1 + localDetectionResult.getBarcodeColumnCount();
    localDetectionResult.setDetectionResultColumn(0, localDetectionResultRowIndicatorColumn1);
    localDetectionResult.setDetectionResultColumn(j, localDetectionResultRowIndicatorColumn2);
    boolean bool1;
    int k;
    if (localDetectionResultRowIndicatorColumn1 != null)
    {
      bool1 = true;
      k = 1;
      label189: if (k > j)
        break label442;
      if (!bool1)
        break label227;
    }
    label227: for (int m = k; ; m = j - k)
    {
      if (localDetectionResult.getDetectionResultColumn(m) == null)
        break label237;
      k++;
      break label189;
      bool1 = false;
      break;
    }
    label237: boolean bool2;
    label257: Object localObject;
    label270: int n;
    int i1;
    label289: int i2;
    if ((m == 0) || (m == j))
      if (m == 0)
      {
        bool2 = true;
        localObject = new DetectionResultRowIndicatorColumn(localBoundingBox, bool2);
        localDetectionResult.setDetectionResultColumn(m, (DetectionResultColumn)localObject);
        n = -1;
        i1 = localBoundingBox.getMinY();
        if (i1 <= localBoundingBox.getMaxY())
        {
          i2 = getStartColumn(localDetectionResult, m, i1, bool1);
          if ((i2 >= 0) && (i2 <= localBoundingBox.getMaxX()))
            break label363;
          if (n != -1)
            break label359;
        }
      }
    while (true)
    {
      i1++;
      break label289;
      break;
      bool2 = false;
      break label257;
      localObject = new DetectionResultColumn(localBoundingBox);
      break label270;
      label359: i2 = n;
      label363: Codeword localCodeword = detectCodeword(paramBitMatrix, localBoundingBox.getMinX(), localBoundingBox.getMaxX(), bool1, i2, i1, paramInt1, paramInt2);
      if (localCodeword != null)
      {
        ((DetectionResultColumn)localObject).setCodeword(i1, localCodeword);
        n = i2;
        int i3 = localCodeword.getWidth();
        paramInt1 = Math.min(paramInt1, i3);
        int i4 = localCodeword.getWidth();
        paramInt2 = Math.max(paramInt2, i4);
      }
    }
    label442: return createDecoderResult(localDetectionResult);
  }

  private static DecoderResult decodeCodewords(int[] paramArrayOfInt1, int paramInt, int[] paramArrayOfInt2)
    throws FormatException, ChecksumException
  {
    if (paramArrayOfInt1.length == 0)
      throw FormatException.getFormatInstance();
    int i = 1 << paramInt + 1;
    int j = correctErrors(paramArrayOfInt1, paramArrayOfInt2, i);
    verifyCodewordCount(paramArrayOfInt1, i);
    DecoderResult localDecoderResult = DecodedBitStreamParser.decode(paramArrayOfInt1, String.valueOf(paramInt));
    localDecoderResult.setErrorsCorrected(Integer.valueOf(j));
    localDecoderResult.setErasures(Integer.valueOf(paramArrayOfInt2.length));
    return localDecoderResult;
  }

  private static Codeword detectCodeword(BitMatrix paramBitMatrix, int paramInt1, int paramInt2, boolean paramBoolean, int paramInt3, int paramInt4, int paramInt5, int paramInt6)
  {
    int i = adjustCodewordStartColumn(paramBitMatrix, paramInt1, paramInt2, paramBoolean, paramInt3, paramInt4);
    int[] arrayOfInt = getModuleBitCount(paramBitMatrix, paramInt1, paramInt2, paramBoolean, i, paramInt4);
    if (arrayOfInt == null)
      return null;
    int j = PDF417Common.getBitCountSum(arrayOfInt);
    int m;
    if (paramBoolean)
      m = i + j;
    while (!checkCodewordSkew(j, paramInt5, paramInt6))
    {
      return null;
      for (int k = 0; k < arrayOfInt.length / 2; k++)
      {
        int i2 = arrayOfInt[k];
        arrayOfInt[k] = arrayOfInt[(-1 + arrayOfInt.length - k)];
        arrayOfInt[(-1 + arrayOfInt.length - k)] = i2;
      }
      m = i;
      i = m - j;
    }
    int n = PDF417CodewordDecoder.getDecodedValue(arrayOfInt);
    int i1 = PDF417Common.getCodeword(n);
    if (i1 == -1)
      return null;
    return new Codeword(i, m, getCodewordBucketNumber(n), i1);
  }

  private static BarcodeMetadata getBarcodeMetadata(DetectionResultRowIndicatorColumn paramDetectionResultRowIndicatorColumn1, DetectionResultRowIndicatorColumn paramDetectionResultRowIndicatorColumn2)
  {
    BarcodeMetadata localBarcodeMetadata1;
    if (paramDetectionResultRowIndicatorColumn1 != null)
    {
      localBarcodeMetadata1 = paramDetectionResultRowIndicatorColumn1.getBarcodeMetadata();
      if (localBarcodeMetadata1 != null);
    }
    else if (paramDetectionResultRowIndicatorColumn2 != null);
    BarcodeMetadata localBarcodeMetadata2;
    do
    {
      return null;
      return paramDetectionResultRowIndicatorColumn2.getBarcodeMetadata();
      if (paramDetectionResultRowIndicatorColumn2 != null)
      {
        localBarcodeMetadata2 = paramDetectionResultRowIndicatorColumn2.getBarcodeMetadata();
        if (localBarcodeMetadata2 != null);
      }
      else
      {
        return localBarcodeMetadata1;
      }
    }
    while ((localBarcodeMetadata1.getColumnCount() != localBarcodeMetadata2.getColumnCount()) && (localBarcodeMetadata1.getErrorCorrectionLevel() != localBarcodeMetadata2.getErrorCorrectionLevel()) && (localBarcodeMetadata1.getRowCount() != localBarcodeMetadata2.getRowCount()));
    return localBarcodeMetadata1;
  }

  private static int[] getBitCountForCodeword(int paramInt)
  {
    int[] arrayOfInt = new int[8];
    int i = 0;
    int j = -1 + arrayOfInt.length;
    while (true)
    {
      if ((paramInt & 0x1) != i)
      {
        i = paramInt & 0x1;
        j--;
        if (j < 0)
          return arrayOfInt;
      }
      arrayOfInt[j] = (1 + arrayOfInt[j]);
      paramInt >>= 1;
    }
  }

  private static int getCodewordBucketNumber(int paramInt)
  {
    return getCodewordBucketNumber(getBitCountForCodeword(paramInt));
  }

  private static int getCodewordBucketNumber(int[] paramArrayOfInt)
  {
    return (9 + (paramArrayOfInt[0] - paramArrayOfInt[2] + paramArrayOfInt[4] - paramArrayOfInt[6])) % 9;
  }

  private static int getMax(int[] paramArrayOfInt)
  {
    int i = -1;
    int j = paramArrayOfInt.length;
    for (int k = 0; k < j; k++)
      i = Math.max(i, paramArrayOfInt[k]);
    return i;
  }

  private static int[] getModuleBitCount(BitMatrix paramBitMatrix, int paramInt1, int paramInt2, boolean paramBoolean, int paramInt3, int paramInt4)
  {
    int i = paramInt3;
    int[] arrayOfInt = new int[8];
    int j = 0;
    if (paramBoolean);
    for (int k = 1; ; k = -1)
    {
      bool = paramBoolean;
      while (true)
      {
        if (((!paramBoolean) || (i >= paramInt2)) && ((paramBoolean) || (i < paramInt1) || (j >= arrayOfInt.length)))
          break label112;
        if (paramBitMatrix.get(i, paramInt4) != bool)
          break;
        arrayOfInt[j] = (1 + arrayOfInt[j]);
        i += k;
      }
    }
    j++;
    if (!bool);
    for (boolean bool = true; ; bool = false)
      break;
    label112: if ((j == arrayOfInt.length) || (((paramBoolean) && (i == paramInt2)) || ((!paramBoolean) && (i == paramInt1) && (j == -1 + arrayOfInt.length))))
      return arrayOfInt;
    return null;
  }

  private static int getNumberOfECCodeWords(int paramInt)
  {
    return 2 << paramInt;
  }

  private static DetectionResultRowIndicatorColumn getRowIndicatorColumn(BitMatrix paramBitMatrix, BoundingBox paramBoundingBox, ResultPoint paramResultPoint, boolean paramBoolean, int paramInt1, int paramInt2)
  {
    DetectionResultRowIndicatorColumn localDetectionResultRowIndicatorColumn = new DetectionResultRowIndicatorColumn(paramBoundingBox, paramBoolean);
    for (int i = 0; i < 2; i++)
    {
      int j;
      int m;
      label42: Codeword localCodeword;
      if (i == 0)
      {
        j = 1;
        k = (int)paramResultPoint.getX();
        m = (int)paramResultPoint.getY();
        if ((m > paramBoundingBox.getMaxY()) || (m < paramBoundingBox.getMinY()))
          continue;
        localCodeword = detectCodeword(paramBitMatrix, 0, paramBitMatrix.getWidth(), paramBoolean, k, m, paramInt1, paramInt2);
        if (localCodeword != null)
        {
          localDetectionResultRowIndicatorColumn.setCodeword(m, localCodeword);
          if (!paramBoolean)
            break label121;
        }
      }
      label121: for (int k = localCodeword.getStartX(); ; k = localCodeword.getEndX())
      {
        m += j;
        break label42;
        j = -1;
        break;
      }
    }
    return localDetectionResultRowIndicatorColumn;
  }

  private static int getStartColumn(DetectionResult paramDetectionResult, int paramInt1, int paramInt2, boolean paramBoolean)
  {
    if (paramBoolean);
    Codeword localCodeword1;
    for (int i = 1; ; i = -1)
    {
      boolean bool = isValidBarcodeColumn(paramDetectionResult, paramInt1 - i);
      localCodeword1 = null;
      if (bool)
        localCodeword1 = paramDetectionResult.getDetectionResultColumn(paramInt1 - i).getCodeword(paramInt2);
      if (localCodeword1 == null)
        break label66;
      if (!paramBoolean)
        break;
      return localCodeword1.getEndX();
    }
    return localCodeword1.getStartX();
    label66: Codeword localCodeword2 = paramDetectionResult.getDetectionResultColumn(paramInt1).getCodewordNearby(paramInt2);
    if (localCodeword2 != null)
    {
      if (paramBoolean)
        return localCodeword2.getStartX();
      return localCodeword2.getEndX();
    }
    if (isValidBarcodeColumn(paramDetectionResult, paramInt1 - i))
      localCodeword2 = paramDetectionResult.getDetectionResultColumn(paramInt1 - i).getCodewordNearby(paramInt2);
    if (localCodeword2 != null)
    {
      if (paramBoolean)
        return localCodeword2.getEndX();
      return localCodeword2.getStartX();
    }
    for (int j = 0; isValidBarcodeColumn(paramDetectionResult, paramInt1 - i); j++)
    {
      paramInt1 -= i;
      for (Codeword localCodeword3 : paramDetectionResult.getDetectionResultColumn(paramInt1).getCodewords())
        if (localCodeword3 != null)
        {
          if (paramBoolean);
          for (int n = localCodeword3.getEndX(); ; n = localCodeword3.getStartX())
            return n + i * j * (localCodeword3.getEndX() - localCodeword3.getStartX());
        }
    }
    if (paramBoolean)
      return paramDetectionResult.getBoundingBox().getMinX();
    return paramDetectionResult.getBoundingBox().getMaxX();
  }

  private static boolean isValidBarcodeColumn(DetectionResult paramDetectionResult, int paramInt)
  {
    return (paramInt >= 0) && (paramInt <= 1 + paramDetectionResult.getBarcodeColumnCount());
  }

  private static DetectionResult merge(DetectionResultRowIndicatorColumn paramDetectionResultRowIndicatorColumn1, DetectionResultRowIndicatorColumn paramDetectionResultRowIndicatorColumn2)
    throws NotFoundException, FormatException
  {
    if ((paramDetectionResultRowIndicatorColumn1 == null) && (paramDetectionResultRowIndicatorColumn2 == null));
    BarcodeMetadata localBarcodeMetadata;
    do
    {
      return null;
      localBarcodeMetadata = getBarcodeMetadata(paramDetectionResultRowIndicatorColumn1, paramDetectionResultRowIndicatorColumn2);
    }
    while (localBarcodeMetadata == null);
    return new DetectionResult(localBarcodeMetadata, BoundingBox.merge(adjustBoundingBox(paramDetectionResultRowIndicatorColumn1), adjustBoundingBox(paramDetectionResultRowIndicatorColumn2)));
  }

  public static String toString(BarcodeValue[][] paramArrayOfBarcodeValue)
  {
    Formatter localFormatter = new Formatter();
    for (int i = 0; i < paramArrayOfBarcodeValue.length; i++)
    {
      Object[] arrayOfObject1 = new Object[1];
      arrayOfObject1[0] = Integer.valueOf(i);
      localFormatter.format("Row %2d: ", arrayOfObject1);
      int j = 0;
      if (j < paramArrayOfBarcodeValue[i].length)
      {
        BarcodeValue localBarcodeValue = paramArrayOfBarcodeValue[i][j];
        if (localBarcodeValue.getValue().length == 0)
          localFormatter.format("        ", (Object[])null);
        while (true)
        {
          j++;
          break;
          Object[] arrayOfObject2 = new Object[2];
          arrayOfObject2[0] = Integer.valueOf(localBarcodeValue.getValue()[0]);
          arrayOfObject2[1] = localBarcodeValue.getConfidence(localBarcodeValue.getValue()[0]);
          localFormatter.format("%4d(%2d)", arrayOfObject2);
        }
      }
      localFormatter.format("%n", new Object[0]);
    }
    String str = localFormatter.toString();
    localFormatter.close();
    return str;
  }

  private static void verifyCodewordCount(int[] paramArrayOfInt, int paramInt)
    throws FormatException
  {
    if (paramArrayOfInt.length < 4)
      throw FormatException.getFormatInstance();
    int i = paramArrayOfInt[0];
    if (i > paramArrayOfInt.length)
      throw FormatException.getFormatInstance();
    if (i == 0)
    {
      if (paramInt < paramArrayOfInt.length)
        paramArrayOfInt[0] = (paramArrayOfInt.length - paramInt);
    }
    else
      return;
    throw FormatException.getFormatInstance();
  }
}

/* Location:           C:\Users\user\Desktop\dd28_pcdd720\classes_dex2jar.jar
 * Qualified Name:     com.google.zxing.pdf417.decoder.PDF417ScanningDecoder
 * JD-Core Version:    0.6.2
 */